Présentation Cours ICS

Représentation d'un champ scalaire
Représentation d'une courbe paramétrée

Leonard Hardiman

Représentation d’un champ scalaire

Qu’est-ce qu’un champ scalaire ?

Un champ scalaire est un scalaire (autrement dit un nombre) dont la valeur varie selon le point de l’espace considéré. Par exemple, la température est un champ scalaire : \[T=f(x,y,z).\]

La température est un champ scalaire de trois variables, car la température est mesurée en un point de l’espace 3D. Aujourd’hui, nous concentrons notre attention sur les champs scalaires de deux variables, en particulier à cet exemple: \[ f(x,y) = \frac{10x}{1+x^2+y^2}. \]

Il y a plusieurs manières de visualiser un champ scalaire de deux variables :

en 2D à l’aide de courbes de niveau \((z_0 = f(x,y))\) ou en image;
en 3D sous la forme d’une surface permettant de visualiser la valeur \(z=f(x,y)\).

Définition d’une grille de points en 2D

import numpy as np
x = y = np.linspace(-4.,4.,41)          # nos coordonnées
xv, yv = np.meshgrid(x,y,indexing='ij') # nos coordonnées vectorisées

Définition d’une grille de points en 2D

import numpy as np
x = y = np.linspace(-4.,4.,41)          # nos coordonnées             
xv, yv = np.meshgrid(x,y,indexing='ij') # nos coordonnées vectorisées

xv et yv sont les tableaux 41 par 41 suivants : \[\mathsf{xv} = \begin{bmatrix} \mathsf{x_0} & \mathsf{x_0} & \cdots & \mathsf{x_0} \\ \mathsf{x_1} & \mathsf{x_1} & \cdots & \mathsf{x_1} \\ \vdots & \vdots & \ddots & \vdots \\ \mathsf{x_{40}} & \mathsf{x_{40}} & \cdots & \mathsf{x_{40}} \end{bmatrix}, \quad \mathsf{yv} = \begin{bmatrix} \mathsf{y_0} & \mathsf{y_1} & \cdots & \mathsf{y_{40}} \\ \mathsf{y_0} & \mathsf{y_1} & \cdots & \mathsf{y_{40}} \\ \vdots & \vdots & \ddots & \vdots \\ \mathsf{y_0} & \mathsf{y_1} & \cdots & \mathsf{y_{40}} \end{bmatrix}\] Ces derniers satisfont (xv[i,j],yv[i,j]) = (x[i],y[j]).

On calcule alors la valeur de notre fonction aux points de la grille :

fv = 10*xv/(1 + xv**2 + yv**2)

Grâce à nos coordonnées vectorisées, le calcul peut être effectué entièrement en appliquant des opérations aux tableaux, plutôt qu’en utilisant des boucles (ce qui est beaucoup plus lent).

Première visualisation 2D: courbes de niveau

import matplotlib.pyplot as plt 
plt.title("Représentation sous la forme de courbes de niveau")
fig = plt.figure()          # pour créer la figure
ax = fig.gca()              # pour créer les axes ("get the current axes")
ax.axis('equal')            # même échelle sur les deux axes
cs = ax.contour(xv,yv,fv,9) # "contour set"
cs.clabel(inline=True, fontsize=9)
plt.show()

Première visualisation 2D: courbes de niveau

import matplotlib.pyplot as plt 
plt.title("Représentation sous la forme de courbes de niveau")
fig = plt.figure()          # pour créer la figure
ax = fig.gca()              # pour créer les axes ("get the current axes")
ax.axis('equal')            # même échelle sur les deux axes
cs = ax.contour(xv,yv,fv,9) # "contour set"
cs.clabel(inline=True, fontsize=9)
plt.show()

ax.contour est une méthode (des axes) qui prend en entrée notre grille de coordonnées 2D (xv,yv), notre tableau de valeurs de fonction (fv) et un entier spécifiant le nombre de courbes de niveau à dessiner (9).
La méthode retourne ensuite un objet ContourSet (essentiellement une visualisation des courbes de niveau, avec quelques méthodes utiles pour les manipuler).

Première visualisation 2D: courbes de niveau

import matplotlib.pyplot as plt 
plt.title("Représentation sous la forme de courbes de niveau")
fig = plt.figure()          # pour créer la figure
ax = fig.gca()              # pour créer les axes ("get the current axes")
ax.axis('equal')            # même échelle sur les deux axes
cs = ax.contour(xv,yv,fv,9) # "contour set"
cs.clabel(inline=True, fontsize=9)
plt.show()

Visualisation 2D alternative: une image

import matplotlib.pyplot as plt 
plt.title("Représentation sous la forme d'une image")
fig = plt.figure()          # pour créer la figure
ax = fig.gca()              # pour créer les axes ("get the current axes")
ax.axis('equal')            # même échelle sur les deux axes
ax.imshow(fv.T)

plt.show()

ax.imshow est une méthode (des axes) qui prend notre tableau de valeurs de fonction transposé (fv.T). La transposition est nécessaire car imshow traite le premier axe comme y (lignes) et le deuxième comme x (colonnes), contrairement à contour qui suit la convention mathématique.

Notez que, comme la méthode ne prend pas nos coordonnées en argument, les étiquettes x et y sont erronées.

Visualisation 2D alternative: une image

import matplotlib.pyplot as plt 
plt.title("Représentation sous la forme d'une image")
fig = plt.figure()          # pour créer la figure
ax = fig.gca()              # pour créer les axes ("get the current axes")
ax.axis('equal')            # même échelle sur les deux axes
ax.imshow(fv.T, extent=[-4, 4, -4, 4])

plt.show()

Notez que, comme la méthode ne prend pas nos coordonnées en argument, les étiquettes x et y sont erronées.

Comme notre grille coordiante est régulière, nous pouvons corriger cela avec l’option extend, mais dans d’autres cas, ce serait plus difficile.

Première visualisation 3D: courbes de niveau

import matplotlib.pyplot as plt
plt.title("Représentation sous la forme de courbes de niveau (en 3D)")
fig = plt.figure()              # pour créer la figure                         
ax = plt.axes(projection='3d')  # pour créer les axes 

cs = ax.contour(xv,yv,fv,9)

plt.show()

En appelant simplement la méthode contour sur des axes 3D, on obtient un ContourSet qui visualise en 3D les courbes de niveau.

Ici, l’altitude (coordonnée \(z\)) d’une courbe est donnée par sa valeur associée.

Deuxième visualisation 3D: une surface

import matplotlib.pyplot as plt; from matplotlib import cm
plt.title("Représentation 3D de la surface $z=f(x,y)$")
fig = plt.figure()              # pour créer la figure 
ax = plt.axes(projection='3d')  # pour créer les axes  

ax.plot_surface(xv,yv,fv,cmap = cm.viridis)

plt.show()

Les axes 3D ont une autre méthode, plot_surface, qui, comme contour, prend xv, yv et fv comme argument, ainsi qu’un ‘colour map’, utilisée pour traduire les valeurs de la fonction en couleurs qui sont appliquées à la surface.

On peut également retrouver nos courbes de niveau.

Représentation 3D de la surface \(z=f(x,y)\)

Représentation d’une courbe paramétrée

Qu’est-ce qu’une courbe paramétrée ?

Soit \(I\) un intervalle. Une courbe paramétrée par le paramètre \(t \in I\) est donnée par

\[\vec{r}(t) = \begin{pmatrix} x(t) \\ y(t) \end{pmatrix} \in \mathbb{R}^{2}, \ \text{en deux dimensions} \\[2em] \vec{r}(t) = \begin{pmatrix} x(t) \\ y(t) \\ z(t) \end{pmatrix} \in \mathbb{R}^{3}, \ \text{en trois dimensions.} \]

Pour spécifier une courbe paramétrée, il suffit donc de spécifier les fonctions \(x(t)\), \(y(t)\) et potentiellement \(z(t)\) (si on travaille en trois dimensions).

On peut considérer l’exemple en deux dimensions suivant: \[ \begin{cases} x(t) = R\, t -d \sin(t)\\ y(t) = R -d \cos(t), \end{cases} \] où \(R\) et \(d\) sont dans \(\mathbb{R}^{>0}\). Une courbe de cette forme est appelée une Trochoïde.

Visualiser une courbe paramétrée (2D)

On commence par construire nos fonctions \(x(t)\) et \(y(t)\) (ici appelées courbe_x et courbe_y).

import numpy as np
import matplotlib.pyplot as plt
R = 3
d = 4
t = np.linspace(-2*np.pi,2*np.pi,100)
courbe_x = R*t - d*np.sin(t)
courbe_y = R - d*np.cos(t)

Puis, on passe à la visualisation:

fig = plt.figure() # pour créer la figure
ax = fig.gca()     # pour créer les axes
plt.axis('scaled')
ax.plot(courbe_x, courbe_y, linewidth=2)
plt.show()

Visualiser une courbe paramétrée (2D)

On commence par construire nos fonctions \(x(t)\) et \(y(t)\) (ici appelées courbe_x et courbe_y).

import numpy as np
import matplotlib.pyplot as plt
R = 3
d = 4
t = np.linspace(-2*np.pi,2*np.pi,100)
courbe_x = R*t - d*np.sin(t)
courbe_y = R - d*np.cos(t)

Puis, on passe à la visualisation:

fig = plt.figure() # pour créer la figure
ax = fig.gca()     # pour créer les axes
plt.axis('scaled')
ax.plot(courbe_x, courbe_y, linewidth=2)
plt.show()

Une trochoïde est la courbe tracée par un point situé à l’extrémité d’un segment de longueur \(d\) qui tourne avec un cercle de rayon \(R\) lorsqu’il roule sur une droite. La cardioïde est le cas particulier où \(d = R\).

Visualiser une courbe paramétrée (3D)

Comme précédemment, on définit tout d’abord nos fonctions.

import numpy as np
import matplotlib.pyplot as plt
t = np.linspace(-2*np.pi,2*np.pi,100)
courbe_x = 1 + np.cos(t) 
courbe_y = np.sin(t)
courbe_z = 2*np.sin(t/2)

On considère donc ici la courbe paramétrée \[ \begin{cases} x(t) = 1 + \cdot \cos(t)\\ y(t) = \sin(t)\\ z(t) = 2 \sin\left(\frac{t}{2}\right), \end{cases} \] où \(t \in [-2\pi,2\pi]\).

Visualiser une courbe paramétrée (3D)

Comme précédemment, on définit tout d’abord nos fonctions.

import numpy as np
import matplotlib.pyplot as plt
t = np.linspace(-2*np.pi,2*np.pi,100)
courbe_x = 1 + np.cos(t) 
courbe_y = np.sin(t)
courbe_z = 2*np.sin(t/2)

On considère donc ici la courbe paramétrée \[ \begin{cases} x(t) = 1 + \cdot \cos(t)\\ y(t) = \sin(t)\\ z(t) = 2 \sin\left(\frac{t}{2}\right), \end{cases} \] où \(t \in [-2\pi,2\pi]\). On passe à la visualisation:

fig = plt.figure() 
ax = plt.axes(projection='3d')
ax.plot(courbe_x, courbe_y, courbe_z)
plt.show()